import { getObjType } from '../utils/util'
import { getSheetIndex } from '../methods/get'
import Store from '../store'
import $ from 'jquery'

//动态数组计算
function dynamicArrayCompute(dynamicArray) {
    let dynamicArray_compute = {}

    if(getObjType(dynamicArray) == 'array'){
        for(let i = 0; i < dynamicArray.length; i++){
            let d_row = dynamicArray[i].r
            let d_col = dynamicArray[i].c
            let d_f = dynamicArray[i].f

            if(Store.flowdata[d_row][d_col] != null && Store.flowdata[d_row][d_col].f != null && Store.flowdata[d_row][d_col].f == d_f){
                if((d_row + '_' + d_col) in dynamicArray_compute){
                    dynamicArray_compute = dynamicArraySpillEditCompute(dynamicArray_compute, d_row , d_col)
                }

                let d_data = dynamicArray[i].data
                let d_rowlen = d_data.length
                let d_collen = 1

                if(getObjType(d_data[0]) == 'array'){
                    d_collen = d_data[0].length
                }

                if(dynamicArrayRangeIsAllNull({ 'row': [d_row, d_row + d_rowlen - 1], 'column': [d_col, d_col + d_collen - 1] }, Store.flowdata)){
                    for(let x = 0; x < d_rowlen; x++){
                        for(let y = 0; y < d_collen; y++){
                            let rowIndex = d_row + x
                            let colIndex = d_col + y

                            if(getObjType(d_data[0]) == 'array'){
                                dynamicArray_compute[rowIndex + '_' + colIndex] = {'v': d_data[x][y], 'r': d_row, 'c': d_col}
                            }
                            else{
                                dynamicArray_compute[rowIndex + '_' + colIndex] = {'v': d_data[x], 'r': d_row, 'c': d_col}
                            }
                        }
                    }
                }
                else{
                    dynamicArray_compute[d_row + '_' + d_col] = {'v': '#SPILL!', 'r': d_row, 'c': d_col}
                }
            }
        }
    }

    return dynamicArray_compute
}

function dynamicArraySpillEditCompute(computeObj, r, c) {
    let rowIndex = computeObj[r + '_' + c].r
    let colIndex = computeObj[r + '_' + c].c

    for(let x in computeObj){
        if(x == (rowIndex + '_' + colIndex)){
            computeObj[x].v = '#SPILL!'
        }
        else if(computeObj[x].r == rowIndex && computeObj[x].c == colIndex){
            delete computeObj[x]
        }
    }

    return computeObj
}

//范围是否都是空单元格(除第一个单元格)
function dynamicArrayRangeIsAllNull(range, data) {
    let r1 = range['row'][0], r2 = range['row'][1]
    let c1 = range['column'][0], c2 = range['column'][1]

    let isAllNull = true
    for(let r = r1; r <= r2; r++){
        for(let c = c1; c <= c2; c++){
            if(!(r == r1 && c == c1) && data[r][c] != null && data[r][c].v != null && data[r][c].v.toString() != ''){
                isAllNull = false
                break
            }
        }
    }

    return isAllNull
}

//点击表格区域是否属于动态数组区域
function dynamicArrayHightShow(r, c) {
    let dynamicArray = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)]['dynamicArray'] == null ? [] : Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)]['dynamicArray']
    let dynamicArray_compute = dynamicArrayCompute(dynamicArray)

    if((r + '_' + c) in dynamicArray_compute && dynamicArray_compute[r + '_' + c].v != '#SPILL!'){
        let d_row = dynamicArray_compute[r + '_' + c].r
        let d_col = dynamicArray_compute[r + '_' + c].c

        let d_f = Store.flowdata[d_row][d_col].f

        let rlen, clen
        for(let i = 0; i < dynamicArray.length; i++){
            if(dynamicArray[i].f == d_f){
                rlen = dynamicArray[i].data.length

                if(getObjType(dynamicArray[i].data[0]) == 'array'){
                    clen = dynamicArray[i].data[0].length
                }
                else{
                    clen = 1
                }
            }
        }

        let d_row_end = d_row + rlen - 1
        let d_col_end = d_col + clen - 1

        let row = Store.visibledatarow[d_row_end],
            row_pre = d_row - 1 == -1 ? 0 : Store.visibledatarow[d_row - 1]
        let col = Store.visibledatacolumn[d_col_end],
            col_pre = d_col - 1 == -1 ? 0 : Store.visibledatacolumn[d_col - 1]

        $('#luckysheet-dynamicArray-hightShow').css({
            'left': col_pre,
            'width': col - col_pre - 1,
            'top': row_pre,
            'height': row - row_pre - 1,
            'display': 'block'
        })
    }
    else{
        $('#luckysheet-dynamicArray-hightShow').hide()
    }
}

export {
    dynamicArrayCompute,
    dynamicArraySpillEditCompute,
    dynamicArrayRangeIsAllNull,
    dynamicArrayHightShow,
}